Efficient streaming based lazily-evaluated machine learning framework

ABSTRACT

An efficient, streaming-based, lazily-evaluated machine learning (ML) framework is provided. An ML pipeline of operators produce and consume a chain of dataviews representing a computation over data. Non-materialized (e.g., virtual) views of data in dataviews permit efficient, lazy evaluation of data on demand regardless of size (e.g., in excess of main memory). Data may be materialized by DataView cursors (e.g., movable windows over rows of an input dataset or DataView). Computation and data movement may be limited to rows for active columns without processing or materializing unnecessary data. A chain of dataviews may comprise a chain of delegates that reference a chain of functions. Assembled pipelines of schematized compositions of operators may be validated and optimized with efficient execution plans. A compiled chain of functions may be optimized and executed in a single call. Dataview based ML pipelines may be developed, trained, evaluated and integrated into applications.

CROSS-REFERENCE TO RELATED APPLICATION

This application claims priority to U.S. Provisional Application No. 62/843,245, filed on May 3, 2019, and entitled “Efficient Streaming Based Lazily-Evaluated Machine Learning Framework,” the entirety of which is incorporated by reference herein.

BACKGROUND

Machine learning (ML) may be used to train a model (e.g. with training data) to make data-based decisions, such as assigning labels to input data based on patterns learned from training data.

SUMMARY

This Summary is provided to introduce a selection of concepts in a simplified form that are further described below in the Detailed Description. This Summary is not intended to identify key features or essential features of the claimed subject matter, nor is it intended to be used to limit the scope of the claimed subject matter.

Methods, systems and computer program products are provided for an efficient, streaming-based, lazily-evaluated machine learning (ML) framework. An ML pipeline of operators produce and consume a chain of dataviews representing a computation over data. Non-materialized (e.g., virtual) views of data in dataviews permit efficient, lazy evaluation of data on demand regardless of size (e.g., in excess of main memory). Data may be materialized by DataView cursors (e.g., movable windows over rows of an input dataset or DataView). Computation and data movement may be limited to rows for active columns without processing or materializing unnecessary data. A chain of dataviews may comprise a chain of delegates that reference a chain of functions. Assembled pipelines of schematized compositions of operators may be validated and optimized with efficient execution plans. A compiled chain of functions may be optimized and executed in a single call. Dataview based ML pipelines may be developed, trained, evaluated and integrated into applications.

Further features and advantages of the invention, as well as the structure and operation of various embodiments, are described in detail below with reference to the accompanying drawings. It is noted that the invention is not limited to the specific embodiments described herein. Such embodiments are presented herein for illustrative purposes only. Additional embodiments will be apparent to persons skilled in the relevant art(s) based on the teachings contained herein.

BRIEF DESCRIPTION OF THE DRAWINGS/FIGURES

The accompanying drawings, which are incorporated herein and form a part of the specification, illustrate embodiments of the present application and, together with the description, further serve to explain the principles of the embodiments and to enable a person skilled in the pertinent art to make and use the embodiments.

FIG. 1 shows a block diagram of a system for an efficient, streaming-based, lazily-evaluated ML framework, according to an example embodiment.

FIG. 2 shows a block diagram of a composition of an ML model, according to an example embodiment.

FIG. 3 shows a table providing an example of a dataview representing a chain of delegates, according to an example embodiment.

FIG. 4 shows a table providing an example of materialized values based on cursoring and execution of a chain of delegate functions, according to an example embodiment.

FIG. 5 shows a flowchart of a method for lazy evaluation of input data by an ML pipeline, according to an example embodiment.

FIG. 6 shows a flowchart of a method for lazy evaluation of input data by an ML pipeline, according to an example embodiment.

FIG. 7 shows a flowchart of a method for lazy evaluation of input data by an ML pipeline, according to an example embodiment.

FIG. 8 shows a block diagram of an example computing device that may be used to implement example embodiments.

The features and advantages of the present invention will become more apparent from the detailed description set forth below when taken in conjunction with the drawings, in which like reference characters identify corresponding elements throughout. In the drawings, like reference numbers generally indicate identical, functionally similar, and/or structurally similar elements. The drawing in which an element first appears is indicated by the leftmost digit(s) in the corresponding reference number.

DETAILED DESCRIPTION I. Introduction

The present specification and accompanying drawings disclose one or more embodiments that incorporate the features of the present invention. The scope of the present invention is not limited to the disclosed embodiments. The disclosed embodiments merely exemplify the present invention, and modified versions of the disclosed embodiments are also encompassed by the present invention. Embodiments of the present invention are defined by the claims appended hereto.

References in the specification to “one embodiment,” “an embodiment,” “an example embodiment,” etc., indicate that the embodiment described may include a particular feature, structure, or characteristic, but every embodiment may not necessarily include the particular feature, structure, or characteristic. Moreover, such phrases are not necessarily referring to the same embodiment. Further, when a particular feature, structure, or characteristic is described in connection with an example embodiment, it is submitted that it is within the knowledge of one skilled in the art to effect such feature, structure, or characteristic in connection with other embodiments whether or not explicitly described.

In the discussion, unless otherwise stated, adjectives such as “substantially” and “about” modifying a condition or relationship characteristic of a feature or features of an example embodiment of the disclosure, are understood to mean that the condition or characteristic is defined to within tolerances that are acceptable for operation of the embodiment for an application for which it is intended.

Numerous exemplary embodiments are described as follows. It is noted that any section/subsection headings provided herein are not intended to be limiting. Embodiments are described throughout this document, and any type of embodiment may be included under any section/subsection. Furthermore, embodiments disclosed in any section/subsection may be combined with any other embodiments described in the same section/subsection and/or a different section/subsection in any manner.

II. Example Implementations

A trainable model may be referred to as a machine learning (ML) model. An ML algorithm may be used to train a model (e.g., with training data) to make data-based decisions (e.g., predictions), such as assigning labels to input data based on patterns learned from training data. An application may use a model to make data-based decisions that would be extremely difficult for an application developer to author, e.g., due to complex statistical nature.

Applications and models represent distinct fields of software engineering and data science that are developed, deployed and managed separately by different processes and/or entities. Previous attempts to provide ML model support to applications may lack in one or more areas. Scikit-learn (SKL) is an example. SKL is an ML library for the Python programming language. SKL provides classification, regression and clustering algorithms designed to operate with Python numerical and scientific libraries NumPy and SciPy. Python-based libraries inherit many syntactic idiosyncrasies and language constraints (e.g., interpreted execution, dynamic typing, global interpreter locks that restrict parallelization), making them suboptimal for high-performance applications targeting a myriad of devices. Additionally, SKL cannot train a model with a voluminous dataset larger than computer primary memory. Also, SKL consumes significant memory resources as a function of materializing an input data set and performing all transformations. Even further, SKL consumes significant processing resources by performing one step at a time before subsequent steps can begin and by performing all steps on all data before any output is available.

Accordingly, methods, systems, and computer program products are herein provided for an efficient, streaming-based, lazily-evaluated machine learning (ML) framework. An ML pipeline of operators produce and consume a chain of dataviews representing a computation over data. Non-materialized (e.g., virtual) views of data in dataviews permit efficient, lazy evaluation of data on demand regardless of size (e.g., in excess of main memory). Data may be materialized by DataView cursors (e.g., movable windows over rows of an input dataset or DataView). Computation and data movement may be limited to rows for active columns without processing or materializing unnecessary data. A chain of dataviews may comprise a chain of delegates that reference a chain of functions. Assembled pipelines of schematized compositions of operators may be validated and optimized with efficient execution plans. A compiled chain of functions may be optimized and executed in a single call. Dataview based ML pipelines may be developed, trained, evaluated and integrated into applications.

Such embodiments may be implemented in various environments. For instance, FIG. 1 shows a block diagram of a system 100 for an efficient, streaming-based, lazily-evaluated ML framework, according to an example embodiment. Example system 100 may comprise, for example, a computing device 105, one or more servers 125, and storage 130, which are communicatively coupled by a network 140. FIG. 1 presents one of many computing environments that may implement subject matter described herein.

Computing device 105 may comprise any computing device. Computing device 105 may be, for example, any type of stationary or mobile computing device, such as a mobile computer or mobile computing device (e.g., a Microsoft® Surface® device, a personal digital assistant (PDA), a laptop computer, a notebook computer, a tablet computer such as an Apple iPad™, a netbook, etc.), a mobile phone, a wearable computing device, or other type of mobile device, or a stationary computing device such as a desktop computer or PC (personal computer), or a server. Computing device 105 may comprise one or more applications, operating systems, virtual machines, storage devices, etc. that may be executed, hosted, and/or stored therein or via one or more other (e.g., networked) computing devices. In an example, computing device 105 may access one or more server computing devices (e.g., over a network). An example computing device with example features is presented in FIG. 8, which is described in detail further below.

Server(s) 125 may comprise one or more servers, such as one or more application servers, database servers, authentication servers, etc. Server(s) 125 may support operations interactions with computing device 105 and storage 130. Server(s) 125 may serve data and/or programs to computing device 105. Programs may include, for example, an application developer framework (e.g., .NET framework), a model development framework (e.g., ML.NET framework), applications (e.g., .NET applications), etc. Server(s) 125 may provide application programming interfaces (APIs) for application 110 to interact with storage 130. Server(s) 125 may comprise, for example, a database engine or management system (DBMS), such as when storage 130 comprises a database. An example of a database server is Microsoft Azure SQL Server. Server(s) 125 may manage storing, processing, and securing and retrieving data in storage 130. Application 110 may use storage 130, for example, to store and/or retrieve data, such as ML training data, test data and/or prediction data.

Storage 130 may comprise one or more storage devices. Storage 130 may store data and/or programs (e.g., information). Data may be stored in storage 130 in any format, including arrays, tables, etc. In a table data embodiment, storage 130 may contain many tables (e.g., hundreds, thousands, millions, tens of millions) with many rows and/or columns (e.g., hundreds, thousands, millions, tens of millions). Specific columns and rows may or may not have data entries. Sparsely populated data (e.g., columns with mostly zero entries) may be referred to as sparse data.

Network 140 may include one or more of any of a local area network (LAN), a wide area network (WAN), a personal area network (PAN), a combination of communication networks, such as the Internet, and/or a virtual network. In example implementations, computing device 105 and server(s) 125 may be communicatively coupled via network 105. Server(s) 125 and computing device 105 may each include at least one network interface that enables communications with each other. Examples of such a network interface, wired or wireless, include an IEEE 802.11 wireless LAN (WLAN) wireless interface, a Worldwide Interoperability for Microwave Access (Wi-MAX) interface, an Ethernet interface, a Universal Serial Bus (USB) interface, a cellular network interface, a Bluetooth™ interface, a near field communication (NFC) interface, etc. Further examples of network interfaces are described elsewhere herein.

Computing device 105 may comprise application 110. Application 110 may comprise any type of application. Application 110 may comprise one or more executable programs, dynamic link libraries (DLLs), etc. Application 110 may be developed in an application development framework. In an example, computing device 105 may access application 110 and/or a web-based application development framework via server(s) 125. In an example, application 110 may comprise a .NET (dot-net) application created in a .NET framework. Dot-net is a cross-platform, open source developer platform for building many different types of applications with many different languages, editors and libraries available to build applications for many different environments (e.g., web, mobile, desktop, gaming, and Internet of Things (IoT) environments). Developer languages may include, for example, C#, F# and Visual Basic. Dot-net may provide a managed runtime environment with a just-in-time (JIT) compiler for execution of applications.

Application 110 may interact with a model, integrate a model, support model development, etc. A dashed box in FIG. 1 indicates many possible associations between application 110 and ML model 115. ML model 115 may comprise any type of model composition in any state (e.g., source code in compiled or pre-compiled state, machine code). ML model 115 may be accessed (e.g., called) by and/or integrated in (e.g., to varying degrees) application 110. ML model 115 may be developed, trained and/or tested before, during and/or after development of application 110. In an example, ML model 115 may be created separately, in conjunction with and/or within application 110.

ML model 115 may be developed, for example, in an ML framework (e.g., ML framework 120). In an example, computing device 105 may access a web-based ML framework provided by server(s) 125. ML framework 120 may incorporate trained model functionality (e.g., speech recognition, image classification) in applications. An example of ML framework 120 is ML.NET. In an example, programs written for .NET Framework may incorporate ML models with ML.NET. ML framework 120 (e.g., ML.NET) may be implemented as a (e.g., .NET) machine learning library that allows developers to build (e.g., complex) machine learning pipelines, evaluate them, and utilize them (e.g., directly) for prediction. Model compositions may comprise one or more pipelines. A pipeline may comprise multiple operators, such as data featurization operators and models. In an example, a chain of transformer operators may implement multiple transformation steps that featurize and transform raw input data into one or more features for evaluation by one or more models. Data featurization operators may be followed by one or more models (e.g., ML models). Models may be stacked or form ensembles. Programs written for ML framework 120 may comprise “managed code” (e.g., in contrast to native code), for example, when they execute in a software (e.g., runtime) environment (e.g., in contrast to a hardware environment). In an example, a .NET runtime (e.g., Common Language Runtime (CLR)) is an application virtual machine that executes managed code while providing services, such as memory management, thread management, security, type safety, exception handling and garbage collection (e.g., for unused memory allocations).

ML framework 120 may be unified, extensible, scalable and efficient. A unified framework may host a variety of models and components. Trained ML pipelines (e.g., ML model 115) may be deployable into production environments. ML pipelines may be scalable to operate with any processor and memory configuration regardless of training or prediction data dimensions. Integration of applications and an ML model toolkit (e.g., ML.NET) may, for example, (i) limit library dependencies; (ii) handle voluminous (e.g., training) datasets too large to fit in computer primary memory (e.g., RAM); (iii) scale to many or few cores and nodes; (iv) be portable across multiple (e.g., many) target platforms; (v) be model class agnostic (e.g., since different ML problems may have different model classes); and, (vi) capture a full prediction pipeline. A full pipeline may, for example, take a test example from a given domain (e.g., an email with headers and body) and produce a prediction that may be structured and domain-specific (e.g., a collection of likely short responses). Encapsulating predictive pipelines may (e.g., effectively) decouple application logic from model development. Utilizing a (e.g., complete) train-time pipeline in production may support building efficient, reproducible, production-ready models (e.g., ML model 115).

ML framework 120 may provide a DataView system. A dataview system may comprise interfaces and components that provide efficient, compositional processing of schematized data for ML and advanced analytics applications. A dataview system may efficiently handle high dimensional data and large data sets (e.g., larger than main memory). A DataView system may provide efficient executions, for example, through streaming data access, immutability and lazy evaluation. DataView system components or operators may include, for example, data loaders, transformers, estimators, algorithms, trainers, etc.

FIG. 2 shows a block diagram of a system 200 for implementing an ML model 215, according to an example embodiment. In particular, FIG. 2 provides a visual depiction of an example of a code implementation of ML model 215. ML model 215 includes a prediction model 205 and a featurizer 210. Prediction model 205 includes a trainer 206 and a prediction model (PM). Featurizer 210 includes a loader 225 and first-nth transformers T1-Tn. Example system 200 is presented as a simple example. Other examples or implementations may be significantly more complex. Example system 200 may comprise ML model 215 and storage 230.

Storage 230 may comprise one or more local and/or remote storage devices. In an example, storage 230 may comprise, for example, storage for a computing device (e.g., computing device 105) or a remote database accessible through a database server (e.g., server(s) 125). Storage 230 may store, for example, one or more of training data 231, test data 232 and prediction data 233, which may be provided (e.g., streamed) as input data 234 to ML model 215.

ML model 215 may comprise a trainable model with one or more trainable components, elements or operators. ML model 215 may have a variety of states, such as untrained, trained, tested, untested, source (code), compiled (code), uncompiled (code) and so on. ML model refers to an ML model in any state.

ML model 215 may implement a dataview system (e.g., provided by an ML framework). A dataview comprises a representation of or a reference to a computation over data, which is a non-materialized view of the data. A DataView is the result of computations over input/source data (e.g., one or more base tables such as training data 231) and/or dataviews. A DataView may represent a computation up to its location in an ML pipeline. DataView components may be combined for compositional pipelines. ML model 215, comprising a chain of operators, may be compilable into a chain of dataviews. A dataview may be lazily evaluated, for example, to conserve resources and to provide partial results faster. A dataview may be lazily evaluated unless, for example, forced to be materialized (e.g., for multiple passes over data). DataView may provide streaming access to data, for example, so that working sets may exceed the size of main memory.

A dataview may represent the input and/or output of operators (e.g., pipeline elements such as transformers). A dataview may comprise a collection of rows and columns. A view may have any number of columns. A dataview may comprise schema information. A DataView schema may specify (e.g., for each column), for example, a column name, index, data type and annotation. A schema may be presented as a schema object. Schemas may be used to define expected input and output (e.g., read and write) dataviews for pipelined dataview system components. A (e.g., each) column may have an associated name, index, data type and (e.g., optionally) an annotation. Types may include, for example, text, Boolean, single and double precision floating point, signed and unsigned integer values, values for ids and unique hashes, date time, time span, key types (e.g., for hash values), vector types, etc. Column type system may be open and may support vector types. In an example, a set of related primitive values may be grouped in a single vector-valued column. In an example, a vector type vector<T, N>type indicates a column's values are vectors of items of type T, with size N, which may be used to represent multi-dimensional data associated rows, such as pixels in an image or tokens in text. Features may be gathered into one or more vector-valued columns. Values may be stored in blocks. A block may hold values for a single column across multiple rows. DataView schemas may be ordered. Multiple columns may share the same name, in which case, one column may hide other columns. Referencing a column by name may (e.g., always) map to the latest column with that name.

A dataview may be distinguished from a table. Tables and views may be schematized and organized into typed columns and rows conforming to the column types. However, a table may comprise a body of data while a view of the data (or of another view) may comprise a result of a query on one or more tables or views. As another example, views may be immutable. In contrast, tables may be mutable. As another example, views may be composable. New views may be formed, for example, by applying transformations (e.g., queries) on other views. In contrast, forming a new table from an existing table may involve copying data, without any link between the new table and the original table. As another example, views may be virtual (e.g., they can be lazily computed on demand from other views or tables without materializing any partial results). In contrast, tables may be realized/persisted. A table contains values in rows while a view may present values computed based on the table or other views, without containing or owning the values. Immutability and compositionality may support reasoning over transformation, such as query optimization and remoting. Immutability may support concurrency and thread safety. Views being virtual may minimize I/O, memory allocation and computation. Information may be accessed, memory may be allocated and computation may be performed, for example, (e.g., only) when needed to satisfy a request for information.

A dataview may support high dimensional data and vector types. In an example, machine learning and advanced analytics applications may involve high-dimensional data. For example, learning from text may utilize, for example, bag-of-words (e.g., FeaturizeText), one-hot encoding or hashing variations to represent non-numerical data. These techniques may generate an enormous number of features. Representing each feature as an individual column may not be ideal. A dataview may represent a (e.g., each) set of features as a single vector column. A vector type may specify an item type and optional dimensionality information. An item type must be a primitive, non-vector, type. Optional dimensionality information may specify the number of items in corresponding vector values. When the size is unspecified, A vector type may be variable length, for example, when a size is not specified. In an example, a TextTokenizer transform (e.g., contained in FeaturizeText) may map a text value to a sequence of individual terms. This transformation may produce variable-length vectors of text. Fixed-size vector columns may be used, for example, to represent a range of a column from an input dataset.

Computations may be composed using dataviews. Operators in an ML framework may be composed using a DataView abstraction to produce efficient machine learning pipelines. A Transformer may be applied to a DataView to produce a derived DataView (e.g., to prepare data for training, testing, or prediction serving). A learner is a machine learning algorithm trained on training data (e.g., provided by a transform) to produce a predictive model (PM). An evaluator may be used for testing a trained model, for example by taking scored test datasets to produce metrics, such as precision, recall, F1, AUC, etc. A loader may be used to represent data sources as a DataView. A saver may serialize DataViews to a form that can be read by a loader.

Transforms may take a DataView as input and produce a DataView as output. A transforms may “add” one or more computed columns to its input schema. An output schema may include all the columns of the input schema, plus some additional columns, whose values may be computed starting from one or more input columns. An added column may have the same name as an input column, in which case, the added column may hide the input column. Multiple primitive transforms may be applied to achieve higher-level semantics. In an example, a FeaturizeText transform may comprise a composition of nine primitive transforms.

Transforms may be fixed or trainable. A fixed transform may, for example, map input data values to output by applying pre-defined computation logic (e.g., Concat). A trainable transform may, for example, have behavior determined (e.g., automatically) from training data. For example, normalizers and dictionary-based mappers translating input values into numerical values (e.g., used in FeaturizeText) may build their state from training data. In an example, given a pipeline, a call to Train may trigger execution of (e.g., all) trainable transforms (e.g., and learners) in topological order. A trained transform (e.g., a learner) may produce a DataView representing computation up to that point in the pipeline. A DataView may be used by downstream operators. In an example, a saved state of a trained transform may be serialized, such that the transform may not be retrained, e.g., when loaded back.

Learners may be similar to trainable transforms. Learners are machine learning algorithms that take DataView as input and produce predictive models, which may comprise transforms that can be applied over input DataViews and produce predictions. Learners may be used, for example, for binary classification, regression, multi-class classification, ranking, clustering, anomaly detection, recommendation and sequence prediction tasks.

A dataview representation of or reference to a computation over data may comprise delegates that represent (e.g., point to) delegate functions to compute data values. A delegate may interpret or operate on (e.g., perform computations on) data. Entries in a dataview may comprise delegates (e.g., as opposed to realized values in a table). A delegate may comprise or reference code that performs a task. A delegate may be a type of data structure that represents references to methods with a particular parameter list and return type. A delegate may be similar to a function pointer. A delegate may be used to pass a method as an argument or parameter to another method.

A cursor may be used to access data referenced by a dataview (e.g., delegate entries in rows and columns). ML pipelines may be compiled into chains of DataViews, where data is accessed through cursoring. A dataview may be a source of cursors. A cursor is an object that iterates through data or dataviews (e.g., one row at a time) and presents available entries (e.g., in active columns). In an example, rows of a dataview may be accessed (e.g., sequentially) via a row cursor. A row cursor may be acquired (e.g., from or for a view), for example, by calling a GetRowCursor method. A row cursor may comprise a movable window on a (e.g., single) row of a view, known as a current row. A row cursor may provide column values (e.g., for active columns) in a current row. A (e.g., each) cursor may have one or more (e.g., a set of) active columns, which may be specified at cursor construction time. A row cursor may advance to another (e.g., the next) row, for example, by calling the MoveNext() method. Multiple cursors may be active (e.g., on the same or different threads) on the same view (e.g., sequentially and in parallel). Views may support multiple iterations through rows. Shuffling rows may be supported via an optional random number generator passed at cursor construction time.

Values represented in a dataview may not be fetched directly from rows using a cursor (e.g., a RowCursor). A delegate may be used to fetch objects (e.g., using a getgetter method on a row). In an example procedure, client code may ask a dataview for a cursor. The request may include specification of which columns should be active and whether shuffling should be performed. The dataview may create and return the requested cursor. Client code may request (e.g. from the cursor) a Getter delegate for each active column, which may be obtained, for example, by using a GetGetter method on the cursor. Delegates returned by a GetGetter method may be tied to the Cursor they are requested for. Delegates returned by calling the GetGetter method on a Cursor may be “chained,” e.g., leveraging delegates provided by Cursors of DataViews higher up the chain. This may be transparent to client code. Client code may advance the cursor from one row to the next, for example, using a MoveNext method on the cursor. The value of an active column for a current row (i.e. the row a cursor is on) may be obtained by invoking the Getter delegate for the active column.

Parallel processing may improve performance. Parallel processing may be implemented, for example, in an algorithm and/or by parallel cursoring. In an example, a transform may acquire a cursor set from its input DataView. Cursors sets may be propagated upstream until a data source is found. A cursor set may, e.g., at this point, be mapped into available threads. Data may be collaboratively scanned. Cursor sets may return a consolidated, unique, cursor, e.g., from a callers' perspective. A cursor's data scan may be split into concurrent threads, e.g., from an execution perspective.

Parallel cursoring may enable (e.g., computation heavy) pipelines to leverage multiple cores without complicating each individual transform implementation. A set of cursors may be requested (e.g., using GetRowCursor method directed to an input view) for parallel execution, for example, when a transform may benefit from parallelism. Each of multiple cursors executed in parallel may serve up a subset of rows. Multiple cursors may be implemented in one or more components of a transformation chain. A component in the chain (e.g., a loader) may determine how many cursors should be active, create and return the cursors. Multiple cursors may be independently processed in different threads. Multiple cursors may be converted back into a single cursor. Splitting into multiple cursors may be done at a loader level or at an arbitrary point in a pipeline. A (e.g., pipeline) component that performs splitting may provide cursor consolidation logic. Intervening components may create a cursor on each input cursor, return that set of cursors and a consolidator.

Randomization may be provided. Some trainers (e.g., training algorithms) may request that the order of rows produced by a cursor be randomized or shuffled. A DataView may indicate (e.g., via a property) whether it supports shuffling. Shuffling may be implemented (e.g. by a dataview) with random numbers. In an example, a random number generator may be passed to a DataView's GetRowCursor method.

Intermediate data may be inspected, for example, during loading, processing, and model training. Intermediate data is the output of each stage in an ML pipeline. Intermediate data may be loaded into a DataView. In an example, an IDataView may be inspected by converting it to an Enumerable (e.g., using a CreateEnumerable method). In an (e.g., alternative) example (e.g., to iterate over rows of a DataView without conversion to an enumerable), a DataViewRowCursor may be created, for example, using a GetRowCursor method, passing a DataViewSchema of a DataView as a parameter. A MoveNext cursor may be used to iterate over rows along with ValueGetter delegates to extract respective values from a (e.g., each) column. Values in a column of a DataView may be accessed using a GetColumn method, which may return all values in a column as an Enumerable.

Dataviews may be (e.g., are) immutable and computations over data may be repeatable. Cursoring through data may not modify input/source data. Operations performed to materialize derived data for dataviews may be repeatable (e.g., values produced by two cursors constructed from the same view with the same arguments to GetRowCursor are identical). Performance may be enhanced (e.g., for multiple passes over a DataView pipeline), for example, by caching, which may be implemented transparent to a learning algorithm (e.g., due to immutability). Immutability supports parallel execution of a composed data pipeline graph and flexible scheduling without cloning source data.

Performance may be proportional to data movements and computations involved in scanning dataview rows. As iterators in database, cursors may be pull-based. In an example, e.g., after an initial setup phase that specifies active columns, cursors may not access data, for example, unless explicitly asked to. This may limit computations and data movements to those needed to materialize requested rows and column values within a row. This may (e.g., also) support efficient streaming of large data sets (e.g., directly from disk), without concern whether working sets fit into main memory.

A dataview system supports lazy evaluation or computation of training, evaluation or prediction data. Lazy evaluation or computation involves computing only what is needed when it is needed, which may conserve resources and generate results faster, for example, when only a subset of data may be processed to fulfill a request. Dataviews may be generated (e.g., and associated operations such as transformers may be executed), for example, (e.g., only) as and when needed. Calling a component may not result in computation. Consuming data (e.g., requesting or creating a cursor on a dataview) may, for example, invoke transformation logic to generate an output dataview. Instantiated component objects may represent promises of data. When declared, data operators may not immediately process data, but may validate that the operation is possible. Execution may be deferred until output data is requested. Computation for other columns and rows irrelevant to the request may be avoided, for example, when only a subset of columns or a subset of rows is requested. In an example implementation, there may be a default (e.g., which may be selectively overridden) to perform only computation needed for the requested columns and rows. Some transforms, loaders, and caching scenarios may be (e.g., fixed or selectively) speculative or eager in their computation. Previews may be provided for dataviews, transformers and estimators (e.g., output provided based on the first 100 rows of data).

Lazy computation may be provided in column and/or row directions. Computations may be limited to active (e.g., selected) columns and rows. A down-stream component in a data pipeline may request only a (e.g., small) subset of information produced by the pipeline. For example, code seeking to display the first 100 rows does not need to iterate through millions of rows. Similarly, code seeking to build a dictionary of terms used in one text column does not need to iterate over any other columns. Lazy upstream computations, performed as needed, may execute significantly faster and use significantly fewer resources than eager up-stream computation (i.e. always performing all computations).

In an example of lazy computation in the column direction, a row cursor may have a set of active columns, which may be determined by arguments passed to GetRowCursor. A cursor, and any upstream components, may (e.g., by default that may or may not be overridden) perform (e.g., only) computation or data movement necessary to provide values of active columns, but not inactive columns. For example, a ValueToKeyMapping Transformer may build a term dictionary from an input IDataView. The transformer may obtain a row cursor from the input view with only the term column active, avoiding data loading and computation that is not required to materialize the term column. In an example of lazy computation in the row direction, cursor computation and data movements may be limited to iterate over a small subset of (e.g., active) input rows needed to materialize the requested rows.

In an example, a (e.g., each) pipeline operator (e.g., transformer) may limit processing to rows and columns involved in providing requested output. For example, a first trainer may only need column X values to train and column X values may be determined by only a few columns produced by previous transform(s). A dataview system may traverse the DAG relationship chain to determine which transforms need to do computations and which columns need to be pulled in by loader to avoid unnecessary work. The determined transforms and columns may (e.g., then) be processed to provide output with minimal work.

CPU efficiency may be provided. Output of an initialization process at each DataView's cursor (e.g., where each cursor in an ML pipeline checks active columns and expected input types) may be a lambda function, which may be referred to as a getter. A getter may condense the logic of an operator into a single call. A (e.g., each) getter may, in turn, trigger the generation of a getter function of an upstream cursor until a data source is found (e.g., a cached DataView or input data). When all getters are initialized, an (e.g., each) upstream getter function may be used in a downstream getter, such that, from an outer cursor perspective, computation may be represented as a chain of lambda function calls. Upon completion of an initialization process, a cursor may iterate over input data and execute training or prediction logic by calling its getter function. At execution time, a chain of getter functions may be JIT-compiled (e.g., by a .NET runtime) to form an (e.g., a unique, highly) efficient function executing a whole pipeline (e.g., up to that point) on a (e.g., single) call. The process may be repeated, for example, until no trainable operator is left in the pipeline.

A DataView system may support any data size, for example, by streaming data. ML pipeline operators may efficiently handle high-dimensional and large datasets with cursoring. DataView supports streaming, for example, by cursoring through dataviews. A pipeline may support efficient multiple pass streaming (e.g., in support of very large datasets). The root of a view may be a loader that pulls information from a file or other data source. Loaders and savers may comprise, for example, binary idv (e.g., dataview interfaces) and text-based loaders and savers. Operating system cache may transparently enhance performance, for example, for repeated passes over a small dataset or a dataset that fits in primary memory (e.g., RAM).

Memory efficiency may be provided in a dataview system. Cursoring may provide efficient memory allocation. Creating a row cursor is an inexpensive operation relative to resource utilization. The expense may be incurred in the data movement and computation involved in iterating over the rows. For example, MoveNext() (e.g., to move a cursor to a next row) may not require memory allocation. Retrieving primitive column values from a cursor may not require memory allocation. A caller may (e.g., optionally) provide buffers to copy values (e.g., to retrieve vector column values from a cursor). A cursor may implement methods that provide values of the current row, e.g., when requested. Methods that serve up values may not require memory allocation on each invocation, for example, because they may use sharable buffers. This may significantly reduce memory allocations needed to cursor through data. Buffers may be shared or reused for other rows without additional memory allocation, for example, when the provided buffers are sufficiently large to hold values. Cooperative buffer sharing may eliminate allocation of separate buffers for each row. Buffers may be allocated outside an iteration loop. DataView may allow ML algorithms to cursor through source data and (e.g., alternatively) build an in-memory representation of information.

ML model 215 (e.g., with a dataview system) makes data-based decisions (e.g., predictions), for example, based on input data 234. Input data 234 may be processed (e.g., transformed or featurized) by featurizer 210 to identify or create features for prediction model 205 to evaluate for predictions. A trained ML model is (e.g., essentially) a transformer that takes input data and returns predictions, where the transformer may comprise multiple operations. ML model 215 may comprise (e.g., all) information necessary to predict a label of a domain object (e.g., image or text) from input data 234. Thus, (e.g., trained) ML model 215 may contain transformations (e.g., data transformation(s) and prediction transformation(s)) to perform on input data 234 to arrive at predicted output. ML model 215 may include fixed and/or trainable parameters for (i) data featurization by a featurizer (e.g., one or more transformers that transform input data to create or identify features) and/or (ii) a prediction function (e.g., a prediction model). A data transformation (e.g., a transformer or a featurizer) may be fixed or trainable. A prediction model and may be fixed or trainable. A trainable prediction model may be referred to as a learner. A trainable transformer/featurizer may be referred to as an estimator.

ML model 215 may be created, for example, by a user of computing device 105. A user may, for example, create a composition of elements, components or operators, e.g., in the form of an ML pipeline, in an ML framework. Example ML model 215 is simplified, with a single pipeline. Other examples or implementations may have multiple (e.g., parallel) pipelines.

A pipeline (e.g., an ML pipeline) comprises all operators/operations utilized to fit a trainable model to a data set. A pipeline may comprise, for example, data import, fixed or trainable data transformation (e.g., data featurization) and prediction model(s) (e.g., fixed model or trainable/learning model). A trainable pipeline may be in a trained or untrained state, where a trained pipeline specifies trainable parameters of ML model 215. A pipeline may be trainable (e.g., comprise one or more trainable elements). For example, a trainable or learning pipeline may include one or more trainable transformers (e.g., estimators) and/or one or more trainable models or algorithms (e.g., trainers). A trained ML model is created when a trainable/learning pipeline is “fit” to training data (e.g., training data 231). A pipeline may be represented as a Direct Acyclic Graphs (DAGs) of operators, where an (e.g., each) operator may comprise a dataview interface executing a data transformation (e.g., string tokenization, hashing, etc.) or an ML model (e.g., decision tree, linear model, SVM, etc.). A pipeline may have a column perspective and an operator perspective, e.g., with respect to graph vertices. While operator chains may be defined linearly, a column schema may create a branching or DAG relationship. For example, column X may be computed (e.g., by an operator) from columns A and B. Column A may come from raw data exposed by a loader (e.g., loader 225). Column B may be computed (e.g., by an operator) from column C. Thus, a column view may provide a branching DAG while a transform view may provide a linear chain. Upon initialization of an ML pipeline, operators composing a model DAG may be analyzed and arranged to form a chain of function calls which, at execution time, may be just-in-time (JIT) compiled to form a function executing the (e.g., entire) pipeline on a single call.

A chain refers to any assembly (e.g. of operators, dataviews or delegates) needed to produce value(s) in (e.g. current) rows of one or more active (e.g. selected) columns. A chain (e.g. a chain of operators, a chain of dataviews, chain of delegates) may be linear or nonlinear (e.g. a DAG). Stated another way, dependencies between chain elements (e.g. delegates) may be linear or nonlinear.

In an example, for each requested column, there may be a delegate that encapsulates the computation needed to produce the value for that column. Such a delegate may leverage/invoke/use zero or more delegates upstream in a dataview chain. A delegate for a second column may leverage/invoke/use some of the same delegates that the first column uses.

In an example described and shown below, suppose that columns requested from DV3 are columns C, D, E, F, and G. Column C in DV3 may be a “pass through” column from DV1. That is, the delegate for producing C from DV3 may be (e.g. is) the delegate used for producing C from DV1. Column D in DV3 may be a “pass through” column from DV2. That is, the delegate for producing D from DV3 may be the delegate used for producing D from DV2. Column E in DV3 may be computed from column D in DV2 and column A in DV1. Column F in DV3 may be computed from column B in DV1. Column G in DV3 may not use any columns upstream in the data view chain. In an example, column G may comprise, for example, a constant value or a randomly generated value. Column D in DV2 may be computed from column A in DV1 and column B in DV1. Dependency relationships are shown with dashed lines below:

Thus, E uses (e.g. depends on) both D and A, D also uses A, as well as B, F uses B, and G doesn't use any upstream delegates. In an example, each dependency shown by dashed lines may be directional, such as in a DAG. For example, each dependency shown may flow upward, indicating the absence of cycles (e.g. mutual dependency of columns on each other).

A letter in parentheses indicates that a delegate is the same delegate as what the delegate points to, e.g., as opposed to being a delegate in its own right that leverages/invokes/uses the delegate it point to. Accordingly, the foregoing dependency relationships may be shown as follows, e.g., to be consistent at intermediate dataviews:

ML model 215 may comprise (e.g., as part of an ML pipeline), for example, featurizer 210 and prediction model 205. ML model 215 may be configured to perform training, test and prediction tasks, e.g., using training data 231, test data 232, or prediction data 233. ML model 215 is presented as a simple example with a single pipeline and a few operators. Other examples or implementations may be significantly more complex, e.g., with multiple pipelines, a significant number of operators and prediction models.

Featurizer 210 may create or extract features from input data 234 so that prediction model 205 may make predictions based on the features. A feature is a measurable property or characteristic of a phenomenon being measured, observed or analyzed by a model. Featurization or feature generation (e.g., from input data) may be important in the creation of accurate ML algorithms or prediction models (e.g., for pattern recognition, classification and regression). Multiple features may be referred to as a feature vector. A vector space or linear space is a collection of vector objects, which may be summed and multiplied (“scaled”) by scalars. Features may be (e.g., represented by) numeric values (e.g., to facilitate processing and statistical analysis). A prediction model (e.g., prediction model 205) may be configured to expect features as a float vector. Data with categorical features may be featurized, for example, by one-hot encoding, hash-based one-hot encoding or binary encoding with a category index. A feature vector may be an n-dimensional vector of numerical features that represents an object. In an example, feature values for image data may correspond to image pixels. Feature values for text data may, for example, correspond to frequencies of occurrence of terms. Feature vectors may be combined with weights, for example, to construct a linear predictor function that may be used to determine a score for making a prediction. An N-gram feature may comprise a sequence of N contiguous items (e.g., phonemes, syllables, letters, words or base pairs) from text or speech data.

Featurizer 210 may process input data 234 into one or more features for prediction model 205. Featurizer 210 may comprise any number and type of operators, which may depend on a configuration of input data 234 and prediction model 205. In an example, e.g., as shown in FIG. 2, featurizer 210 may comprise loader 225, first transformer T1, second transformer T2 and so on to nth transformer Tn.

Although not shown, a context object (e.g., MLContext object) may provide a starting point for an ML application. A context object may provide a catalog of everything available. A context object may be used to read data, create estimators, save/load models, evaluate and perform all other tasks. A context object may contain a catalog object, which may catalog available operations and provide a factory to create components for data loading and saving, data preparation, feature engineering, transforms, training, evaluation and model operation (prediction), evaluation logging, execution control and so on. A (e.g., each) catalog object may comprise methods to create different types of components.

Data loader or loader 225 may indicate how to read input data 234. Input data 234 may be referred to as a dataset or source data, which may comprise (e.g., depending on a task ML model 215 is configured to perform) training data 231, test data 232 or prediction data 233. Input data 234 may comprise, for example, a file, a table (e.g., a collection of rows and columns), etc. Input data 234 may be unsuitable for direct use by prediction model 205. In an example data may be sparse, may contain irrelevant information and/or may otherwise be improperly formatted for prediction model 205. Input data 234 may (e.g., accordingly) be prepared or pre-processed into features before being used to find (e.g., trainable) parameters of prediction model 205. For example, input data 234 may be transformed (e.g., filtered, scaled normalized, encoded or otherwise manipulated) to provide features in a form expected by prediction model 205. In an example, redundant and/or irrelevant information in input data 234 may be filtered out, the dimensions of data may be reduced or expanded and/or data may be converted from text or string values to a numerical representation (e.g., floating point data or floats) that prediction model 205 may be configured to expect as input.

Loader 225 may represent input data 234 as a DataView, e.g., first DataView DV1. Loader 225 may load data from one or types of data or data formats (e.g., files, SQL tables, adhoc data generated on the fly) from one or more data sources (e.g., storage 230). Loader 225 may be schematized. Loader 225 may infer or specify (e.g., in a schema) columns, data types in columns and their locations in one or more input data sources (e.g., input data 234). Input data 234 may be (e.g., lazily) loaded, for example (e.g., only) when dataview output may be called for or requested (e.g., by a downstream pipeline operator). Data loaded as input data 234 from storage 230 may be limited to data necessary to provide requested dataview output.

First through nth transformers T1-n may be used to prepare data for model training or prediction. First through nth transformers T1-n may (e.g., each) apply a transform to convert an input dataview to an output dataview. ML pipeline operators such as transformers (e.g., first through nth transformers T1-n) consume one or more columns of one or more dataviews as input and create one or more columns of one or more dataviews as output. Dataviews are immutable, such that multiple operators at any point (e.g., downstream) in a pipeline may consume the same columns without triggering any re-execution. For example, first transformer T1 may operate on first dataview DV1 to generate as output second dataview DV2, second transformer T2 may operate on second dataview DV2 to generate as output third dataview DV3, etc., with nth transformer Tn operating on nth dataview DVn to generate as output a feature dataview DVf with one or more features (e.g., feature columns) for prediction model 205 to evaluate.

First through nth transformers T1-n may (e.g., variously) be fixed or trainable. A trainable transformer may be created by training an estimator, as indicated by dashed boxes for first through nth estimators E1-n above, respectively, each of first through nth transformers T1-n. Parameters determined for a transform during training (e.g., a fit() operation) may be used by a transformer (e.g., a transform () operation). Some transformers may operate without training parameters (e.g., converttograyscale transform). First through nth transformers T1-n may perform any transformation. First through nth transformers T1-n may, for example, concatenate, copy and rename, scale (e.g., normalize floats by scaling values between 0 and 1), convert or map to different data types, transform text to floats, tokenize text, hash data, transform images, encode data, insert missing values, etc. For example, a transformer may add a column and fill it with values computed from one or more columns in the input dataview. A text tokenizer transformer may, for example, take a text column and output a vector column with words extracted from the text column. In an example (e.g., as shown in FIG. 2), multiple transformers may be chained together (e.g., in a pipeline), which may create transformer dependencies on one or more other transformers.

First through nth transformers T1-n may expect and produce data of specific types and formats, which may be specified in a schema (e.g., dataview schema). For example, each of first through nth transformers T1-n in the ML pipeline may (e.g., must) have an input schema (e.g., data names, types, and sizes that the transform expects to see on its input) and an output schema (e.g., data names, types, and sizes that the transform produces after the transformation). An exception may be thrown, for example, when the output schema from a transform in a pipeline doesn't match an input schema for the next transform.

Regarding trainable transformers, first through nth estimators E1-n are shown in dashed boxes to indicate each estimator may or may not be present in an implementation depending on whether parameters for a respective transform are variable or fixed. An estimator is a specification of a transformation (e.g., for data preparation transformation and machine learning model training transformation). An estimator may represent an untrained, but trainable or learning, transformer, which may be indicated by an IEstimator<TTransformer>Interface. An estimator may be fit on data to create/return a trained transformer. Parameters of an estimator or pipeline of estimators may be learned when Fit is called to return a trained transformer. An ML model or a prediction model may be (e.g., essentially) an estimator (e.g., a trainer) that learns on training data and produces a trained model, which, in turn, may be (e.g., essentially) a trained transformer.

Estimator input may comprise a dataview. Estimator output comprises a trained transformer. In an example, Fit(IDataView) may be called to train and return a transformer. In an example, given an estimator, a wrapping object may be returned that will call a delegate when Fit(IDataView) is called. An estimator may return information about what was fit. A Fit(IDataView) method may return a specifically typed object, e.g., rather than a general ITransformer. In an example (e.g., as shown in FIG. 2), multiple estimators may be chained together into an estimator pipeline (e.g., IEstimator<TTransformer> may be formed into pipelines with many objects). A chain of estimators may be constructed, for example, via EstimatorChain<TLastTransformer>. An estimator that will generate a transformer may be inside a chain of operators.

Prediction model 205 makes predictions based on features in or created from input data 234. Prediction model 205 and may be fixed or trainable. Trained or fixed prediction model 205 may receive feature dataview DVf as input and may generate as output a prediction dataview DVp. A trainable prediction model may be referred to as a learner. A fixed or trained prediction model is (e.g., essentially) a transformer that takes features and returns predictions. Prediction model 205 may comprise (e.g., all) information necessary to predict a label of a domain object (e.g., image or text) from one or more features. Prediction model 205 may include fixed and/or trainable parameters for its prediction function (e.g., algorithm). For example, prediction model 205 may comprise trainable weights applied to a linear regression model or split points in a decision tree.

In an (e.g., a simple) example, prediction model 205 may comprise a linear regression model that predicts house prices using house size and price data (e.g., Price=b+Size*w). Parameters b and w may be estimated (trained) by fitting a line on a set of (Size, Price) pairs. In this example, Size is a feature. Ground-truth values (e.g., empirical evidence) in training data may be referred to as labels. A label is an element to be predicted by a model, such as a future stock price. In this example, Price values in training data may be labels. In other examples and implementations, input data, features and the prediction model may be much more complex.

A trainable prediction model may be trained by a trainer, as indicated by dashed box for trainer 206 above (e.g., fixed or trainable) prediction model PM. Parameters determined for trainable prediction model PM during training (e.g., a fit() operation) may be used to make predictions for prediction data.

Trainer 206 may accept a dataview input (e.g., feature dataview DFf) and produce a trained prediction model (e.g., prediction model PM). Trainer 206 may accept, for example, a feature column, a weight column and a label column. Trainer 206 executes an algorithm applied to a task. Prediction model PM, which operates on features, may be applied to different tasks. In an example, a Stochastic Dual Coordinated Ascent (SDCA) algorithm (optimization technique for convex objective functions) may be used for various tasks, such as Binary Classification, Multiclass Classification and Regression. Output of prediction model PM may be interpreted (e.g., differently) according to the task. Trainer 206 may execute a training algorithm and perform interpretation. For example, SdcaRegressionTrainer may use the SDCA algorithm applied to a Regression task.

A trainable transform (e.g., featurizer 210) and/or a trainable prediction model (e.g., prediction model 205) may be trained before generating an output DataView. An output dataview may, for example, comprise one or more additional columns added to an input dataview. An ML pipeline (e.g., ML model 215) submitted for execution (e.g., by calling Train) may, for example, lead to training each trainable transform/learner in topological order. A one-time initialization cost may be incurred for each trainable operator in ML model 215 to analyze the cursors in the pipeline, e.g., each cursor may check active columns and expected input type(s). Training may determine, generate, identify or fit a model for a given training data set (e.g., training data 231). Training may involve, for example, binary classification, multiclass classification, anomaly detection, clustering, forecasting, ranking, regression, recommendation, etc. In an example of a linear model, training may comprise finding weights. In an example of a tree, training may comprise identifying split points. Training may occur, for example, by calling Fit() with training data 231 as input data 234 to estimate parameters of ML model 215. A resulting model object may implement a Transformer interface.

A model composition (e.g., ML model 215) may be compilable into a chain of dataviews (e.g., DV1-DV2-DV3 . . . DVn-DVf-DVp) based on input data 234. A chain of dataviews may comprise a chain of delegates pointing to a chain of delegate functions.

Runtime (e.g., for a training, testing or prediction task) may interpret ML model 215 as a directed acyclic graph (DAG) of operators (e.g., as opposed to executable code). At runtime, ML model 215 may be registered. Runtime may apply optimizations over ML model 215, such as operator reordering (e.g., to improve latency) or operator and sub-graph sharing, for example, to improve memory consumption and computation reuse (e.g., through caching). Pipeline compositions may be converted into model plans. An Object Store may save and share parameters among plans. A Runtime may manage compiled plans and their execution. A Scheduler may manage dynamic decisions on how to schedule plans (e.g., based on computing device workload). An ML framework FrontEnd may receive and submit prediction requests to ML model 215. An application (e.g., application 110) may request predictions by including the Runtime in its logic.

A pipeline composition may indicate a workflow. A workflow is a pattern of activity (e.g., a procedure or process). In an example workflow (e.g., for model development and deployment), data (e.g., training data 231) may be prepared for a trainable model (e.g., ML model 215). Data may be loaded through a DataView object (e.g., first dataview DV1). A pipeline of data transformations that utilize DataViews (e.g., featurizer 210) may featurize data for an ML algorithm (e.g., prediction model 205). Transformers (e.g., first through nth transformers T1-n) may (e.g., in addition to a trainable model such as prediction model PM) be trained by training data (e.g., using first through nth estimators E1-n to generate first through nth transformers T1-n). The ML pipeline with trainable featurizer and/or trainable prediction model, which defines the workflow, may be trained, for example, by calling fit() on the ML pipeline (e.g., ML model 215). Following training, trained ML model 215 may be evaluated, for example, using test data 232. There may be multiple iterations of training and evaluation to improve performance. A trained and evaluated model may be saved (e.g., in binary format) for use in or by an application (e.g., application 110). The model may be loaded into a transformer object. The loaded model may make predictions, for example, by calling CreatePredictionEngine.Predict() based on prediction data 233.

FIGS. 3 and 4 show examples of dataview entries filled with delegates, for example, compared to entries with materialized values created with delegate functions. In particular, FIG. 3 shows a simple example dataview 300 of prediction dataview DVp in FIG. 2 (in table form) representing a chain of delegates for the chain of dataviews shown in FIG. 2, according to an example embodiment. FIG. 4 shows a simple example dataview 400 of materialized values for prediction dataview DVp (in table form) based on cursoring and execution of a chain of delegate functions, according to an example embodiment.

The example dataview DVp in FIG. 3 represents a simple example of prediction dataview DVp in FIG. 2. Various implementations of dataviews may have any number of columns and rows. Column names include C1, C2, C3-Cn, Feature and Label. In an example, column names C1, C2, C3-Cn, Feature and Label may correlate, respectively, for example, with first through nth dataviews DV1, DV2, DV3-DVn, feature dataview DVf and prediction dataview DVp, where each dataview adds one column to a previous dataview in this simple example. In other examples, there may or may not be a one-to-one correlation between columns and dataviews, for example, given that a dataview may generate multiple columns. In various implementations, columns exposed by different dataviews may or may not “flow through” to the next dataview. For example, a source dataview may have columns A and B, while the next dataview may expose only newly computed columns D, E, and F, while the next dataview may or may not expose columns A and B.

In an example, loader 225 may create first dataview DV1 and column C1, where first delegate D1 represents a computation that would (e.g., selectively) fill rows of first column C1 with text input (e.g., xyz, abc, foo) from source data (e.g., training data 231, test data 232 or prediction data 233). First transformer T1 (e.g., after being trained by first estimator E1) may create second dataview DV2 and column C2, where second delegate D2 in second column C2 represents a computation that would (e.g., selectively) fill rows of second column C2 with numerical representations (e.g., 0, 1, 2) of text input (e.g., xyz, abc, foo) in first column C1 obtained from first dataview DV1. Second transformer T2 (e.g., after being trained by second estimator E 2) may create third dataview DV3 and third column C3, where third delegate D3 in third column C3 represents a computation that would (e.g., selectively) fill rows of third column C3 based on one or more columns of first or second dataviews DV1 or DV2. Nth transformer Tn (e.g., after being trained by nth estimator En) may create feature dataview DVf and Feature column, where feature delegate Df represents a computation that would (e.g., selectively) fill rows of Feature column Cf based on one or more columns of first through nth dataviews DV1 through DVn. In an example, nth transform Tn may transform numerical values in second column C2 into vectors, e.g., by converting the numerical values to one-hot vector values. Prediction model PM (e.g., after being trained by trainer 206) may create prediction dataview DVp and prediction column Label, where prediction delegate Dp represents a computation that would (e.g., selectively) fill rows of prediction column Label based on evaluation of one-hot vector values in feature column in feature dataview DVf In an example, prediction model PM may comprise a binary classifier that classifies one-hot vector values as 0 or 1.

Example prediction dataview DVp represents the last dataview in a chain of dataviews (e.g., first through nth dataviews DV1, DV2, DV3-DVn, feature dataview DVf and prediction dataview DVp). Example prediction dataview DVp shows a chain of delegates (e.g., D1, D2, D3-Dn, Df and Dp) to an input data source (e.g., storage 230.

In an example, such as where a user (e.g., of computing device 105) requests values in Feature column, delegate chaining may be performed to determine which dataviews, delegates and columns are necessary to fulfill the request for materialized value(s). In a simple linear example of delegate chaining, delegate chaining may involve feature delegate Df calling nth delegate Dn and so on, third delegate D3 calling second delegate D2, second delegate D2 calling first delegate D1, and first delegate D1 accessing storage data 230 (e.g., for one of training data 231, test data 232 or prediction data 233 depending on the task) for input data 234. With dataviews, delegates and columns known, first delegate may load input data 234, providing the value(s) to second delegate D2, second delegate D2 may process the loaded input data into numerical values, providing the numerical values to third delegate D3 and so on, nth delegate may provide its output to feature delegate DVf, feature delegate DVf may process those values and provide the resulting values in response to the request. In various implementations, delegate chaining may or may not be linear and delegates may call one or more other delegates. In an example, Df may call D7, D7 may call D4 and D3, D4 may call D1, and so on. Each dataview may contribute one or more delegates and one or more columns.

Implementations are not limited to the examples shown. Any number of computing devices and/or servers (including but not limited to machines and/or virtual machines) may be coupled in any manner via any type of computing environment. For example, one or more of computing device, server or storage components may be co-located, located remote from each other, combined or integrated on or distributed across one or more real or virtual machines. Examples shown and discussed with respect to FIGS. 1-4 may operate, for example, according to example methods presented in FIGS. 5-7.

Embodiments may also be implemented in processes or methods. For example, FIG. 5 shows a flowchart of a method for lazy evaluation of input data by an ML pipeline, according to an example embodiment. Embodiments disclosed herein and other embodiments may operate in accordance with example method 500. Method 500 comprises steps 502-508. However, other embodiments may operate according to other methods. Other structural and operational embodiments will be apparent to persons skilled in the relevant art(s) based on the foregoing discussion of embodiments. No order of steps is required unless expressly indicated or inherently required. There is no requirement that a method embodiment implement all of the steps illustrated in FIG. 5. FIG. 5 is simply one of many possible embodiments. Embodiments may implement fewer, more or different steps.

Method 500 comprises step 502. In step 502, there may be provided a machine learning (ML) pipeline comprising a chain of dataviews representing a computation over data as a non-materialized view of the data. For example, as shown in FIG. 2, ML model 215 comprises a pipeline of operators with a chain of dataviews (e.g., first through nth dataviews DV1, DV2, DV3-DVn, feature dataview DVf and prediction dataview DVp).

In step 504, a request may be received for data from at least one column in a dataview in the chain of dataviews. For example, as shown in FIGS. 1-4, a user of computing device 105 may request values in Feature column of feature dataview DVf in the chain of dataviews first through nth dataviews DV1, DV2, DV3-DVn, feature dataview DVf and prediction dataview DVp.

In step 506, a chain of delegates in the chain of dataviews, including first delegate in a first dataview and a second delegate in a second dataview, may be selected to fulfill the request. For example, as shown in FIGS. 2 and 3, a chain of delegates D1, D2, D3-Dn, Df in the chain of dataviews first through nth dataviews DV1, DV2, DV3-DVn, and feature dataview DVf may be selected to materialize values in Feature column to fulfill the request. As previously indicated, in various implementations, delegate chaining may or may not be linear and delegates may call one or more other delegates. In an example, Df may call D7, D7 may call D4 and D3, D4 may call D1, and so on. Each dataview may contribute one or more delegates and one or more columns.

In step 508, the input data may be processed with the selected chain of delegates to fulfill the request. For example, as shown in FIGS. 2-4, input data 234 may be processed with the chain of delegates D1, D2, D3-Dn, Df to materialize values in the Feature column shown in FIG. 4.

FIG. 6 shows a flowchart of a method 600 for lazy evaluation of input data by an ML pipeline, according to an example embodiment. Embodiments disclosed herein and other embodiments may operate in accordance with example method 600. Method 600 comprises steps 602-608. However, other embodiments may operate according to other methods. Other structural and operational embodiments will be apparent to persons skilled in the relevant art(s) based on the foregoing discussion of embodiments. No order of steps is required unless expressly indicated or inherently required. There is no requirement that a method embodiment implement all of the steps illustrated in FIG. 6. FIG. 6 is simply one of many possible embodiments. Embodiments may implement fewer, more or different steps.

Method 600 comprises step 602. In step 602, a first cursor may be opened on the first dataview in the chain of dataviews to access or load data represented by the first dataview. For example, as shown in FIGS. 2-4, a first cursor may be opened on first dataview DV1 in the chain of dataviews (e.g., first through nth dataviews DV1, DV2, DV3-DVn, feature dataview DVf and prediction dataview DVp) in order to access first delegate D1 in first column C1 to load data from storage 234.

In step 604, a second cursor may be opened on the second dataview in the chain of delegates, based on a dependency between the first and second dataviews, to access data represented by the second dataview. For example, as shown in FIGS. 2-4, a second cursor may be opened on second dataview DV2 in the chain of dataviews, based on a dependence between first and second dataviews DV1 and DV2, to access second delegate D2 in column C2 to transform textual data loaded from storage 234 to numerical data.

In step 606, a first delegate in the first dataview in the chain of delegates may be called to perform a computation to create data represented by the first dataview. For example, as shown in FIGS. 2-4, first delegate D1 (e.g., in first column C1 of first dataview DV1) in a chain of delegates (e.g., D1, D2, D3-Dn, Df) is called so that a first delegate function may load data from storage 234 in column C1.

In step 608, a second delegate in the second dataview may be called, based on a dependency between the first and second delegates, to perform a computation to create data represented by the second dataview. For example, as shown in FIGS. 2-4, second delegate D2 in column C2 of second dataview DV2 is called so that a second delegate function may transform textual data loaded from storage 234 in first column C1 to numerical data in second column C2.

FIG. 7 shows a flowchart of a method 700 for lazy evaluation of input data by an ML pipeline, according to an example embodiment. Embodiments disclosed herein and other embodiments may operate in accordance with example method 700. Method 700 comprises steps 702-708. However, other embodiments may operate according to other methods. Other structural and operational embodiments will be apparent to persons skilled in the relevant art(s) based on the foregoing discussion of embodiments. No order of steps is required unless expressly indicated or inherently required. There is no requirement that a method embodiment implement all of the steps illustrated in FIG. 7. FIG. 7 is simply one of many possible embodiments. Embodiments may implement fewer, more or different steps.

Method 700 comprises step 702. In step 702, a dataview may be provided, where a column of the dataview is a feature column and where a dataview comprises a non-materialized view of data. For example, as shown in FIGS. 2-4, prediction dataview DVp may be provided with delegates as a non-materialized view of data shown in FIG. 4.

In step 704, delegate chaining may be performed on the dataview to determine a set of input columns and a chain of delegates to determine a feature value in the feature column. For example, as shown in FIGS. 2-4, a set of columns comprising first column C1, second column C2, and so on from third column C3 to nth column Cn, and Feature column, and a chain of delegates comprising first delegate D1, second delegate D2, and so on from third delegate D3 to nth delegate Dn, and feature delegate Df, may be determined to compute a value in Feature column.

In step 706, the feature value for the feature column may be determined based on the determined set of input columns and the chain of delegates. For example, as shown in FIGS. 2-4, feature values in Feature column may be determined based on computations performed by delegate functions (e.g., referenced by delegates) on values computed for the set of columns.

In step 708, the feature value may be provided to a machine learning (ML) algorithm to make a prediction based on the feature value. For example, as shown in FIGS. 2-4, feature values shown in FIG. 4 may be provided to prediction model PM to make a prediction of values in the Label column shown in FIG. 4.

III. Example Computing Device Embodiments

As noted herein, the embodiments described, along with any modules, components and/or subcomponents thereof (e.g., computing device 105, ML framework 120, database 130, ML model 215, prediction model 205, featurizer 210, trainer 206, loader 225, first-nth transformers T1-Tn) as well as the flowcharts/flow diagrams described herein (e.g., methods 500, 600, 700), including portions thereof, and/or other embodiments, may be implemented in hardware, or hardware with any combination of software and/or firmware, including being implemented as computer program code configured to be executed in one or more processors and stored in a computer readable storage medium, or being implemented as hardware logic/electrical circuitry, such as being implemented together in a system-on-chip (SoC), a field programmable gate array (FPGA), and/or an application specific integrated circuit (ASIC). A SoC may include an integrated circuit chip that includes one or more of a processor (e.g., a microcontroller, microprocessor, digital signal processor (DSP), etc.), memory, one or more communication interfaces, and/or further circuits and/or embedded firmware to perform its functions.

FIG. 8 shows an exemplary implementation of a computing device 800 in which example embodiments may be implemented. Consistent with all other descriptions provided herein, the description of computing device 800 is a non-limiting example for purposes of illustration. Example embodiments may be implemented in other types of computer systems, as would be known to persons skilled in the relevant art(s).

As shown in FIG. 8, computing device 800 includes one or more processors, referred to as processor circuit 802, a system memory 804, and a bus 806 that couples various system components including system memory 804 to processor circuit 802. Processor circuit 802 is an electrical and/or optical circuit implemented in one or more physical hardware electrical circuit device elements and/or integrated circuit devices (semiconductor material chips or dies) as a central processing unit (CPU), a microcontroller, a microprocessor, and/or other physical hardware processor circuit. Processor circuit 802 may execute program code stored in a computer readable medium, such as program code of operating system 830, application programs 832, other programs 834, etc. Bus 806 represents one or more of any of several types of bus structures, including a memory bus or memory controller, a peripheral bus, an accelerated graphics port, and a processor or local bus using any of a variety of bus architectures. System memory 804 includes read only memory (ROM) 808 and random-access memory (RAM) 810. A basic input/output system 812 (BIOS) is stored in ROM 808.

Computing device 800 also has one or more of the following drives: a hard disk drive 814 for reading from and writing to a hard disk, a magnetic disk drive 816 for reading from or writing to a removable magnetic disk 818, and an optical disk drive 820 for reading from or writing to a removable optical disk 822 such as a CD ROM, DVD ROM, or other optical media. Hard disk drive 814, magnetic disk drive 816, and optical disk drive 820 are connected to bus 806 by a hard disk drive interface 824, a magnetic disk drive interface 826, and an optical drive interface 828, respectively. The drives and their associated computer-readable media provide nonvolatile storage of computer-readable instructions, data structures, program modules and other data for the computer. Although a hard disk, a removable magnetic disk and a removable optical disk are described, other types of hardware-based computer-readable storage media can be used to store data, such as flash memory cards, digital video disks, RAMs, ROMs, and other hardware storage media.

A number of program modules may be stored on the hard disk, magnetic disk, optical disk, ROM, or RAM. These programs include operating system 830, one or more application programs 832, other programs 834, and program data 836. Application programs 832 or other programs 834 may include, for example, computer program logic (e.g., computer program code or instructions) for implementing example embodiments described herein.

A user may enter commands and information into the computing device 800 through input devices such as keyboard 838 and pointing device 840. Other input devices (not shown) may include a microphone, joystick, game pad, satellite dish, scanner, a touch screen and/or touch pad, a voice recognition system to receive voice input, a gesture recognition system to receive gesture input, or the like. These and other input devices are often connected to processor circuit 802 through a serial port interface 842 that is coupled to bus 806, but may be connected by other interfaces, such as a parallel port, game port, or a universal serial bus (USB).

A display screen 844 is also connected to bus 806 via an interface, such as a video adapter 846. Display screen 844 may be external to, or incorporated in computing device 800. Display screen 844 may display information, as well as being a user interface for receiving user commands and/or other information (e.g., by touch, finger gestures, virtual keyboard, etc.). In addition to display screen 844, computing device 800 may include other peripheral output devices (not shown) such as speakers and printers.

Computing device 800 is connected to a network 848 (e.g., the Internet) through an adaptor or network interface 850, a modem 852, or other means for establishing communications over the network. Modem 852, which may be internal or external, may be connected to bus 806 via serial port interface 842, as shown in FIG. 8, or may be connected to bus 806 using another interface type, including a parallel interface.

As used herein, the terms “computer program medium,” “computer-readable medium,” and “computer-readable storage medium” are used to refer to physical hardware media such as the hard disk associated with hard disk drive 814, removable magnetic disk 818, removable optical disk 822, other physical hardware media such as RAMs, ROMs, flash memory cards, digital video disks, zip disks, MEMs, nanotechnology-based storage devices, and further types of physical/tangible hardware storage media. Such computer-readable storage media are distinguished from and non-overlapping with communication media (do not include communication media). Communication media embodies computer-readable instructions, data structures, program modules or other data in a modulated data signal such as a carrier wave. The term “modulated data signal” means a signal that has one or more of its characteristics set or changed in such a manner as to encode information in the signal. By way of example, and not limitation, communication media includes wireless media such as acoustic, RF, infrared and other wireless media, as well as wired media. Example embodiments are also directed to such communication media that are separate and non-overlapping with embodiments directed to computer-readable storage media.

As noted above, computer programs and modules (including application programs 832 and other programs 834) may be stored on the hard disk, magnetic disk, optical disk, ROM, RAM, or other hardware storage medium. Such computer programs may also be received via network interface 850, serial port interface 842, or any other interface type. Such computer programs, when executed or loaded by an application, enable computing device 800 to implement features of example embodiments described herein. Accordingly, such computer programs represent controllers of the computing device 800.

Example embodiments are also directed to computer program products comprising computer code or instructions stored on any computer-readable medium. Such computer program products include hard disk drives, optical disk drives, memory device packages, portable memory sticks, memory cards, and other types of physical storage hardware.

IV. Example Embodiments

Methods, systems and computer program products are provided for an efficient, streaming-based, lazily-evaluated machine learning (ML) framework. An ML pipeline of operators produce and consume a chain of dataviews representing a computation over data. Non-materialized (e.g., virtual) views of data in dataviews permit efficient, lazy evaluation of data on demand regardless of size (e.g., in excess of main memory). Data may be materialized by DataView cursors (e.g., movable windows over rows of an input dataset or DataView). Computation and data movement may be limited to rows for active columns without processing or materializing unnecessary data. A chain of dataviews may comprise a chain of delegates that reference a chain of functions. Assembled pipelines of schematized compositions of operators may be validated and optimized with efficient execution plans. A compiled chain of functions may be optimized and executed in a single call. Dataview based ML pipelines may be developed, trained, evaluated and integrated into applications.

In an example, a method for lazy evaluation of input data by a machine learning (ML) pipeline comprising a chain of dataviews representing a computation over data (e.g., as a non-materialized view of the data), may comprise, for example, receiving a request for data from at least one column in a dataview in the chain of dataviews; selecting a chain of delegates comprising one or more delegates for one or more dataviews in the chain of dataviews (e.g., a first delegate in a first dataview and a second delegate in a second dataview) to (e.g., perform one or more computations to) fulfill the request; and processing the input data (e.g., by iterating over rows of the one or more dataviews while performing the one or more computations) with the selected chain of delegates to (e.g. produce row values for the at least one column to) fulfill the request.

In an example, the method may further comprise, for example, avoiding processing a portion of the input data or a portion of the pipeline unnecessary to fulfill the request.

In an example, the method may further comprise, for example, opening a first cursor on the first dataview in the chain of dataviews to access or load data represented by the first dataview; and opening, based on a dependency between the first and second dataviews, a second cursor on the second dataview in the chain of delegates to access data represented by the second dataview.

In an example, the method may further comprise, for example, calling a first delegate in the first dataview in the chain of delegates to perform a computation to create data represented by the first dataview; and calling, based on a dependency between the first and second delegates, a second delegate in the second dataview to perform a computation to create data represented by the second dataview.

In an example, the request for data may comprise, for example, a request to provide feature values as training data to train the ML pipeline to predict label values.

In an example, the input data may comprise, for example, training data that exceeds available computer memory. The method may further comprise, for example, streaming the input data to the ML pipeline.

In an example, the method may further comprise, for example, executing the ML pipeline in a managed runtime environment; and making the request by an application.

In an example, a computing device may comprise, for example, one or more processors; and one or more memory devices that store program code configured to be executed by the one or more processors. The program code may comprise, for example, a machine-learning (ML) pipeline [object] comprising a chain of operators compilable into a chain of dataviews configured for lazy evaluation of input data, where a dataview comprises a representation of a computation over data as a non-materialized view of the data.

In an example, the chain of operators may comprise, for example, a loader configurable to create an input dataview from input data; a featurizer configurable to create a feature dataview based on the input dataview; and a predictor configurable to make a prediction based on feature values represented by a chain of delegates in the feature dataview and the input dataview.

In an example, the computing device may further comprise, for example, a trainer configured to train the ML pipeline by fitting the feature values to the ML pipeline. In an example, at least one of the featurizer and the algorithm may be trainable.

In an example, the featurizer may comprise a chain of transformers trained or configured to be trained by a chain of estimators based on training data, wherein each trained transformer (i) operates on one or more columns in one or more dataviews and (ii) creates an output dataview in the chain of dataviews.

In an example, the ML pipeline may be configurable to execute a training task, a testing task and a prediction task.

In an example, the input dataview may comprise a table with columns and row. The feature dataview may comprise the input dataview with at least one additional column comprising at least a feature column with a non-materialized view of feature values.

In an example, the feature column of the feature dataview may comprise, for example, a representation of a value getter function configured to open a cursor on a selected row of the input dataview in the chain of dataviews with an instruction to make at least one column of the input dataview active; and a value getter delegate configured to get materialized values in the at least one active column of the selected row.

In an example, a computer-readable storage medium may have program instructions recorded thereon that, when executed by a processing circuit, perform a method comprising, for example, providing a dataview, where a column of the dataview is a feature column and where a dataview comprises a non-materialized view of data; performing delegate chaining on the dataview to determine a set of input columns and a chain of delegates to determine a feature value in the feature column; determining the feature value for the feature column based on the determined set of input columns and the chain of delegates; and providing the feature value to a machine learning (ML) algorithm to make a prediction based on the feature value.

In an example, performing delegate chaining on the dataview may comprise, for example, determining a first function associated with the feature column; determining any input columns that are an input to the first function; and iteratively determining any next functions associated with the input columns, and any next input columns that are an input to the any next functions.

In an example, determining a feature value may comprise, for example, processing the set of input columns with a chain of functions represented by the chain of delegates, the chain of functions comprising the first function and any next functions.

In an example, the method may further comprise, for example, streaming data from storage that stores an input dataset to an ML pipeline comprising the ML algorithm.

In an example, the set of input columns may comprise, for example, a feature vector column in the dataview.

In an example, each delegate in the chain of delegates may reside in a dataview.

In an example of a method for lazy evaluation of input data by a machine learning (ML) pipeline comprising a chain of dataviews, a dataview may represent a computation over data as a non-materialized view of the data. The method may comprise, for example, receiving a request for data for at least one column in a dataview in the chain of dataviews; constructing or calling a delegate for each requested column; using, by each delegate, zero or more additional delegates from zero or more dataviews in or up the chain of dataviews to produce the data for the at least one column; and iterating over the rows of the dataview while invoking the delegates to produce the data for the at least one column.

In an example, a delegate may be associated with a cursor. A cursor may move from row to row. A delegate may get the value for an active column for the current row of a cursor.

In an example of a method for lazy evaluation of input data by a machine learning (ML) pipeline comprising a chain of dataviews, a dataview may represent a computation over data as a non-materialized view of the data. The method may comprise, for example, receiving a request for data for at least one column in a dataview in the chain of dataviews; identifying a computation to produce data values for the at least one column; and iterating over rows of the dataview, performing the computations to produce the data values for the at least one column. In an example, the computation(s) to produce the data values for the at least one column may comprise a delegate.

In an example, the delegate may use zero or more additional delegates (e.g. a chain of delegates) from zero or more dataviews in the chain of dataviews.

V. Conclusion

While various embodiments of the present invention have been described above, it should be understood that they have been presented by way of example only, and not limitation. It will be understood by those skilled in the relevant art(s) that various changes in form and details may be made therein without departing from the spirit and scope of the invention as defined in the appended claims. Accordingly, the breadth and scope of the present invention should not be limited by any of the above-described exemplary embodiments, but should be defined only in accordance with the following claims and their equivalents. 

What is claimed is:
 1. A method for lazy evaluation of input data by a machine learning (ML) pipeline comprising a chain of dataviews, where a dataview represents a computation over data as a non-materialized view of the data, the method comprising: receiving a request for data for at least one column in a dataview in the chain of dataviews; selecting a chain of delegates comprising one or more delegates for one or more dataviews in the chain of dataviews to fulfill the request; and processing the input data with the selected chain of delegates to fulfill the request.
 2. The method of claim 1, further comprising: avoiding processing a portion of the input data or a portion of the pipeline unnecessary to fulfill the request.
 3. The method of claim 1, further comprising: opening a first cursor on the first dataview in the chain of dataviews to access or load data represented by the first dataview; and opening, based on a dependency between the first and second dataviews, a second cursor on the second dataview in the chain of delegates to access data represented by the second dataview.
 4. The method of claim 1, further comprising: calling a first delegate in the first dataview in the chain of delegates to perform a computation to create data represented by the first dataview; and calling, based on a dependency between the first and second delegates, a second delegate in the second dataview to perform a computation to create data represented by the second dataview.
 5. The method of claim 1, wherein the request for data comprises a request to provide feature values as training data to train the ML pipeline to predict label values.
 6. The method of claim 5, wherein the input data comprises training data that exceeds available computer memory, the method further comprising: streaming the input data to the ML pipeline.
 7. The method of claim 6, further comprising: executing the ML pipeline in a managed runtime environment; and making the request by an application.
 8. A computing device, comprising: one or more processors; and one or more memory devices that store program code configured to be executed by the one or more processors, the program code comprising: a machine-learning (ML) pipeline [object] comprising a chain of operators compilable into a chain of dataviews configured for lazy evaluation of input data, where a dataview comprises a representation of a computation over data as a non-materialized view of the data.
 9. The computing device of claim 1, wherein the chain of operators comprises: a loader configurable to create an input dataview from input data; a featurizer configurable to create a feature dataview based on the input dataview; and a predictor configurable to make a prediction based on feature values represented by a chain of delegates in the feature dataview and the input dataview.
 10. The computing device of claim 9, further comprising: a trainer configured to train the ML pipeline by fitting the feature values to the ML pipeline; wherein at least one of the featurizer and the algorithm is trainable.
 11. The computing device of claim 10, wherein the featurizer comprises a chain of transformers trained or configured to be trained by a chain of estimators based on training data, wherein each trained transformer (i) operates on one or more columns in one or more dataviews and (ii) creates an output dataview in the chain of dataviews.
 12. The computing device of claim 9, wherein the ML pipeline is configurable to execute a training task, a testing task and a prediction task.
 13. The computing device of claim 9, wherein the input dataview comprises a table with columns and rows; and wherein the feature dataview comprises the input dataview with at least one additional column comprising at least a feature column with a non-materialized view of feature values.
 14. The computing device of claim 13, wherein the feature column of the feature dataview comprises a representation of a value getter function configured to open a cursor on a selected row of the input dataview in the chain of dataviews with an instruction to make at least one column of the input dataview active; and a value getter delegate configured to get materialized values in the at least one active column of the selected row.
 15. A computer-readable storage medium having program instructions recorded thereon that, when executed by a processing circuit, perform a method comprising: providing a dataview, where a column of the dataview is a feature column and where a dataview comprises a non-materialized view of data; performing delegate chaining on the dataview to determine a set of input columns and a chain of delegates to determine a feature value in the feature column; determining the feature value for the feature column based on the determined set of input columns and the chain of delegates; and providing the feature value to a machine learning (ML) algorithm to make a prediction based on the feature value.
 16. The computer-readable storage medium of claim 15, wherein said performing delegate chaining on the dataview comprises: determining a first function associated with the feature column; determining any input columns that are an input to the first function; and iteratively determining any next functions associated with the input columns, and any next input columns that are an input to the any next functions.
 17. The computer-readable storage medium of claim 16, wherein said determining the feature value comprises: processing the set of input columns with a chain of functions represented by the chain of delegates, the chain of functions comprising the first function and any next functions.
 18. The computer-readable storage medium of claim 15, the method further comprising: streaming data from storage that stores an input dataset to an ML pipeline comprising the ML algorithm.
 19. The computer-readable storage medium of claim 15, wherein the set of input columns comprises a feature vector column in the dataview.
 20. The computer-readable storage medium of claim 15, wherein each delegate in the chain of delegates resides in a dataview. 